﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Drawing;

namespace Noris.Schedule.Schedule.Pics
{
    public static class PicLibrary16
    {
        #region Image Book
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku book.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Book_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Book, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Book_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book.png
        /// </remarks>
        public static System.Drawing.Image Book_Cached
        {
            get
            {
                if (_Book == null) _Book = Book;
                return _Book;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku book.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image Book_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Book_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Book_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book.png
        /// </remarks>
        public static System.Drawing.Image Book { get { return _ImageCreateFrom(_Book_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru book.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Book_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Book_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book.png
        /// </remarks>
        public static System.Drawing.Image Book_FromFile { get { return _ImageCreateFrom(_Book_string, "book.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru Book
        /// </summary>
        /// <returns></returns>
        private static string _Book_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1416);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAAAZiS0dEAAAAAAAA+UO7fwAAAAlwSFlzAAAASAAAAEgARslrPgAAAAl2cEFn");
            sb.Append("AAAAEAAAABAAXMatwwAAAeNJREFUOMt1k79qVUEQxn/n5N6bEBsVRSySoChI4k2ngoLgCyg+gYUgdj6AD6OIldooiIKFsRO0FgtRtIxF/oDJ2d2Z+Sz2RGO8d2EZWHZ+");
            sb.Append("8327M40krt97sCLpqWADcVkICZCoQX92eKGkrW/vHt0/DTCgXrgjODdeXmzWf24h7SVBhQUK2Nz6xW4SocEp+lUBcHW8vNBcW11g8eQYVQKhqFWjVj9+eJ75uQFXbtzl");
            sb.Append("HwDSkfHKEq8+fmFjYwdFABB7KiQUYnN7hy5l9q/eAs1gNODs+SXOnDiKO0hBhHAXHoGF2O0KT56tTQII9+D7+jajdkjXdZSUsajnxgyD4Yhjh2YJaQIACA/MCyklbl48");
            sb.Append("U+VXdUji4dvPlLkhB/L/KigeeDHMWx6vfSIVw1y4BUbDcDQiW33UiQCzIJdCDlA7SzMcQiuiCSKC7A3ZpwKgmGOdkYpjHhSPPlY4DZgPUExT4EFJhVS82nGRe4i5aBuw");
            sb.Append("7FMesbdQcgVYiGyBe1BClOLM0FLmNdlCSGRzLBmpBCUCN1HCKaXvBTnFYtovUC9lrxYiMAvMhFnthVYNbkKIiPjxnwXalguXVlHT4C7MRfRRfTfmbEiQurR2EPDm9cv3");
            sb.Append("t+vk7et/BAcmE/Hi64fnt/YAvwF8+tWWuzrHCwAAACV0RVh0Y3JlYXRlLWRhdGUAMjAwOS0xMS0xNlQyMjoxODoxNi0wNzowMP139XUAAAAldEVYdGRhdGU6Y3JlYXRl");
            sb.Append("ADIwMTAtMDEtMTFUMDY6NTM6MDUtMDc6MDCnZrnaAAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEwLTAxLTExVDA2OjUzOjA1LTA3OjAw1jsBZgAAAGJ0RVh0TGljZW5zZQBo");
            sb.Append("dHRwOi8vY3JlYXRpdmVjb21tb25zLm9yZy9saWNlbnNlcy9ieS8zLjAvIG9yIGh0dHA6Ly9jcmVhdGl2ZWNvbW1vbnMub3JnL2xpY2Vuc2VzL2J5LzIuNS+LhjxlAAAA");
            sb.Append("JXRFWHRtb2RpZnktZGF0ZQAyMDA2LTAzLTEyVDIxOjQ5OjE2LTA3OjAwmOFBgwAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAAbdEVYdFNvdXJj");
            sb.Append("ZQBGQU1GQU1GQU0gU2lsayBJY29uc4J6ZPsAAAAzdEVYdFNvdXJjZV9VUkwAaHR0cDovL3d3dy5mYW1mYW1mYW0uY29tL2xhYi9pY29ucy9zaWxrL8LEDQ0AAAAASUVO");
            sb.Append("RK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Book_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Book_Reset()
        {
            _Book = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Book_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Book = null;
        #endregion
        #region Image Book1
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku book1.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Book1_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Book1, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Book1_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book1.png
        /// </remarks>
        public static System.Drawing.Image Book1_Cached
        {
            get
            {
                if (_Book1 == null) _Book1 = Book1;
                return _Book1;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku book1.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image Book1_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Book1_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Book1_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book1.png
        /// </remarks>
        public static System.Drawing.Image Book1 { get { return _ImageCreateFrom(_Book1_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru book1.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Book1_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Book1_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book1.png
        /// </remarks>
        public static System.Drawing.Image Book1_FromFile { get { return _ImageCreateFrom(_Book1_string, "book1.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru Book1
        /// </summary>
        /// <returns></returns>
        private static string _Book1_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1132);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwgAADsIBFShKgAAAAER0RVh0U291cmNlAEZBTUZBTUZBTSBT");
            sb.Append("aWxrIEljb25zIGh0dHA6Ly93d3cuZmFtZmFtZmFtLmNvbS9sYWIvaWNvbnMvc2lsay+eJpWIAAAAGnRFWHRTb2Z0d2FyZQBQYWludC5ORVQgdjMuNS4xMDD0cqEAAAJ7");
            sb.Append("SURBVDhPrZNNTxNRGIX7D4yJoqINFCw1SoAIiDEIQtQCLTNlaHFqsEhLUsqnBUUBFxhDaDQuTARX7k0E6RdSKoGgMQZLGcDauXfH7P0Px1dx0zBLJjl5k0nO85575o7B");
            sb.Append("cBSPffCdwWWO/3JbPqWd5hhc55cgm+NwFsfRXhSDZCIVRuEonEej8e1+bWcody2ZlWHHV7yf/YFkRMFKeBur0TQS4S0kFlNYmt9E/MMmvn9JI5VKoSyvBzkE2RLffzGe");
            sb.Append("gd+6ju6aVVLynzzVK/BU0axcgZfm32TCubAOoGRJm5nIINizh7mXHHMh0gzH7DTpOcfrKYZXkxyhUYaOkqgOwBzXZp5kIN9U8LQvi0c+BWPeLYzc20LwbgoDzl0Md6iY");
            sb.Append("HmKQinUSUFla6HEGYv0mxnp2sPGZYz3JsZb4r2WOgPATU34VUlHkcAJqWnv2YA+O698w0a0i6FbQ155GQNxGwJ6G77YCvy2LSS9Dm0kvgYkAg3toqtlAUOYYcTH0iSqZ");
            sb.Append("OHy3ODw3VNxv4BiVsxALPuokKIxpk34FQvUaBkSKa2O0lZFJRWctg/sqh1zDCJyl+7B4GCAVRLVxr4K2ylX4rCq6Ghg8dQcmVyVHewVHx2WOh5IKwaiTQCqIaGMeApQn");
            sb.Append("0EVG9zWOO9UcjvIshIsMooXDdYljoEWFw6iTQDwb1UapOGdZAu4rHFIFfa5SDuECQ6uZo7WI3tEcbuKw5S+g9ITvd85NFPIj2oi8iyHHDvoFhn47R6+VIWClPhpJVGBv");
            sb.Append("PcdgI4OdAJZjnsUcQF33G0ObMUbni9GGCFpJ9jNh2EgtpyNoPhVGc14ETSfDsB5fWDZVCUfxDx8w/gAEr7E/uMp0fgAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Book1_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Book1_Reset()
        {
            _Book1 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Book1_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Book1 = null;
        #endregion
        #region Image Book2
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku book2.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Book2_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Book2, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Book2_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book2.png
        /// </remarks>
        public static System.Drawing.Image Book2_Cached
        {
            get
            {
                if (_Book2 == null) _Book2 = Book2;
                return _Book2;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku book2.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image Book2_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Book2_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Book2_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book2.png
        /// </remarks>
        public static System.Drawing.Image Book2 { get { return _ImageCreateFrom(_Book2_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru book2.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Book2_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Book2_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book2.png
        /// </remarks>
        public static System.Drawing.Image Book2_FromFile { get { return _ImageCreateFrom(_Book2_string, "book2.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru Book2
        /// </summary>
        /// <returns></returns>
        private static string _Book2_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1164);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwwAADsMBx2+oZAAAAER0RVh0U291cmNlAEZBTUZBTUZBTSBT");
            sb.Append("aWxrIEljb25zIGh0dHA6Ly93d3cuZmFtZmFtZmFtLmNvbS9sYWIvaWNvbnMvc2lsay+eJpWIAAAAGnRFWHRTb2Z0d2FyZQBQYWludC5ORVQgdjMuNS4xMDD0cqEAAAKT");
            sb.Append("SURBVDhPrZNJT1NRGIb5K7oyrtVExTI5gtEVQQSZ2jJYCCAGBK1CFERMSLEDHSiDTC0IEpTRkApSCr1IqVRGBy4iGNGwENePJ7giZclJ3uXznO97z70hIQdxLufYQ2Jy");
            sb.Append("7B9jsu3vo7PruKQRuWnjosiFLCvnMy2cyzATpdKjuPFoNTSxcu+1AvbdqR1myL3IwpcfzH/eZP7TBoGVdeaWv+FfXGN2Qeb75hbb29scVcSxxxCTXbfaOrZEXk0fyaWd");
            sb.Append("JN137iZR6yDhnoPrd9uJL27bnSxCZQoWRGvqZOfkZ4wjAYYCG/T7N+ibXefVzDd6pDW6plZxer7S6FomWmMNFoh95Tb3CoXtE9hcS+gH/FT3SFR1e3ncOcnDTonHPX5s");
            sb.Append("bxZFL5ZggShLbhEr3GoZxTD4gfXff1n7tYMssrq1w9eff3jglDANzotS9xGIpuUG1wK5DSPo+gJUdkmUOTxoWycoaRqnsMnN3XYJ3euAeBFz8ATnMiyydThApmWAJ71z");
            sb.Append("VHT7KXvh455zhqLWaQqavdxulngi1jibvk+JZ9PNsrHfj1LXK8BZtAK80zYtIC+5jVNo7B409R7KhTRKZQyeIEpdK+t6fSRVdlHcLsAWibwmAQoowzaBsnYctdlNqZBG");
            sb.Append("KA3BgkiVSX7aPU18mYP8Ji85DZNk2jyoLOMkG9+RUDNKUs0YJWKN8LR9BOFKk1zR4SW2pIWsXdBNigATn41yrfotsU9dxFW5KKyfIixNz5HQ2F97vsSwNKNc3iGhbfZQ");
            sb.Append("2ulD65ihWJRX9FyioN5Lvm2KXOsk+RYPilQ9h09cfblHoEg1hESqzUSoawlXmwhTmlCkGTkjxg1NNXA6Rc+pZD0nk55xPL564NCxKwfxD/93/AOyE+YLupmrIgAAAABJ");
            sb.Append("RU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Book2_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Book2_Reset()
        {
            _Book2 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Book2_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Book2 = null;
        #endregion
        #region Image Book3
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku book3.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Book3_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Book3, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Book3_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book3.png
        /// </remarks>
        public static System.Drawing.Image Book3_Cached
        {
            get
            {
                if (_Book3 == null) _Book3 = Book3;
                return _Book3;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku book3.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image Book3_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Book3_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Book3_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book3.png
        /// </remarks>
        public static System.Drawing.Image Book3 { get { return _ImageCreateFrom(_Book3_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru book3.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Book3_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Book3_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book3.png
        /// </remarks>
        public static System.Drawing.Image Book3_FromFile { get { return _ImageCreateFrom(_Book3_string, "book3.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru Book3
        /// </summary>
        /// <returns></returns>
        private static string _Book3_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1116);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwgAADsIBFShKgAAAAER0RVh0U291cmNlAEZBTUZBTUZBTSBT");
            sb.Append("aWxrIEljb25zIGh0dHA6Ly93d3cuZmFtZmFtZmFtLmNvbS9sYWIvaWNvbnMvc2lsay+eJpWIAAAAGnRFWHRTb2Z0d2FyZQBQYWludC5ORVQgdjMuNS4xMDD0cqEAAAJx");
            sb.Append("SURBVDhPrZPNU1JhFMb5U2rRtG+aykDUxFbViKPVFGUlmoAXUD4F1MwEjCSRb+TyJZ8qOgKONiqiNuOYqav23n3/w9OBVgwsvTO/zXvveZ5znvdcHu86nicMy+uyaP50");
            sb.Append("WbTnIvMYOs0adJrG8IjoMI2iY1yNdqMKQu0IWmT9VwKJvd6Wii/l/nlES5vYOT7E9lGlxlaljNLBPorlPRT2d/Hz5ARnZ2e4/bgddQrkfOUqZjGwaEPf3BR6bZM1eqwW");
            sb.Append("YgLiWQu6iWpnAj3TKCAyazj39iq+bEQRPyghUi6BLRcR3isguLsJ3491eHby+FbKQURjNXRA83KurRUoEk7YiylMr0UwmQnBlA7CmPRDm/bDuBqGvZCmPJSNAhQWt0Aj");
            sb.Append("fGTn8DkfxfHlbxxd/MLhxSkqxMH5KUZTXupwmQRUjQKUNOfYTEEatOJTPo7xdACahBtqgom6II+5oCSB6rsOY5MO2sfVnG19Gf3eaZjyLAwrYWiyAagyfihSHgwvuyBL");
            sb.Append("umGi87ZmIbYZVdzMWgyvFqagzYWgzvgwQoUyKpQmvuNDvIoT+uwShLomtyA0KLmpHIvnjgkwaS+5LWIo4aoVvY068Jp14E3EgTEaTUDL1HALrXolZ84sQWwzYYhcB8i1");
            sb.Append("PzYPCfsVL8N29IaseLE0Bybpay5Ay8EZUgE8nTHgXcwJCblVC/tCs+ihYLsDsxAHbJAnfOBr5bglEv6t20S+boTTU3uqhIfCC1IGATApHxRJL4bpbIiQxt0YjLnxkARu");
            sb.Append("tLVs1AkI33t4rXQ9AgNDq6oAX6eofdhCPCDua2WEHPc0MtxRDm7fvPvsOv7h/xr/AExhvoJ2IOctAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Book3_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Book3_Reset()
        {
            _Book3 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Book3_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Book3 = null;
        #endregion
        #region Image BookLink
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku book-link.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu BookLink_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property BookLink, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property BookLink_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book-link.png
        /// </remarks>
        public static System.Drawing.Image BookLink_Cached
        {
            get
            {
                if (_BookLink == null) _BookLink = BookLink;
                return _BookLink;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku book-link.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image BookLink_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití BookLink_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property BookLink_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book-link.png
        /// </remarks>
        public static System.Drawing.Image BookLink { get { return _ImageCreateFrom(_BookLink_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru book-link.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití BookLink_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property BookLink_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book-link.png
        /// </remarks>
        public static System.Drawing.Image BookLink_FromFile { get { return _ImageCreateFrom(_BookLink_string, "book-link.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru BookLink
        /// </summary>
        /// <returns></returns>
        private static string _BookLink_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1680);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAAAZiS0dEAAAAAAAA+UO7fwAAAAlwSFlzAAAASAAAAEgARslrPgAAAAl2cEFn");
            sb.Append("AAAAEAAAABAAXMatwwAAAqhJREFUOMt1kl2IVGUYx39nPHPO5pjb+MGwS+ugKeSuo3cGlV8RQQiFQrgWdJEgwgZdhBfRbTcrJRLlVVCIV+VFd974SV200ArBorkY5mH3");
            sb.Append("HGenmlmdM3M+3vd5ujjumrE+8PLCw/v/Pf//w+uoKm999O2Yqv6g0EZ5WVFUAVWKS5eP2Jw8Xbx7/dynWwBcigfHFV5sjG5yFlqLqC6JoIAJKtBZjOmniqi7mUdVAGBv");
            sb.Append("Y3TEObBzhE1DDbQgICrFVCmmb3xuNasHXF55+wRPAFCtNsbqXPz1Du12DxUBQJZcqKKidB70SNKM/9ajCDiu57JtR52ttXVYC6qCiGKtYkUwovSTnO8vXFsJoFgr3Ft4");
            sb.Append("gFcqkyQJeZphpOgbVuGWPTZUfER1BQAgVjA2J01TDu3eWtgv3KGqfHf1d/KBMv/TP3aQW8HmBmNLnL92kzQ3GKtYIxgcyp5HZoqlrggwRsjynExASz5OuQwlRRxBRMis");
            sb.Append("Q2afCoDcWExi6PX6xHM3GcyabK5t4I8gIl6/C/wKD+/+wtGXatwbGmNiYuLkzMzM2ccOrJD1E4Ibl9k1/AxH3nufOI55YW6Oyz9Nkegq3n3nMF7ZJYoipqenTwVBsPGJ");
            sb.Append("CO3gNtsqD9nz2kFOfnaGf/6cYXhoiEajQRRFnP7ic8IwAm8Nn3z8IUEQHHeXPkxmLPFCwNqdIwAMjL5J79Y04+PjVKtVut0urVaLL786y1/dCgCDg4P+8g6sVRy3Qhg1");
            sb.Append("Aejc+BFQJicnqVQKQRzHlBx4/lmTAAPz8/PJcgRKJXbvf507P1/gyqUrHH7jVXx3D81mk9nZWXzfp16vU6vV6PUTZ2pqqhOG4X1HVdn3wdffqHJMVSDrsKb7G8O19fi+");
            sb.Append("hwPcbq/FqMf26t+UHJUsTfphGLbiOD70L9sBr2vImxxTAAAAJXRFWHRjcmVhdGUtZGF0ZQAyMDA5LTExLTE2VDIyOjE4OjE2LTA3OjAw/Xf1dQAAACV0RVh0ZGF0ZTpj");
            sb.Append("cmVhdGUAMjAxMC0wMS0xMVQwNjo1Mjo1OS0wNzowMMfktvQAAAAldEVYdGRhdGU6bW9kaWZ5ADIwMTAtMDEtMTFUMDY6NTI6NTktMDc6MDC2uQ5IAAAAYnRFWHRMaWNl");
            sb.Append("bnNlAGh0dHA6Ly9jcmVhdGl2ZWNvbW1vbnMub3JnL2xpY2Vuc2VzL2J5LzMuMC8gb3IgaHR0cDovL2NyZWF0aXZlY29tbW9ucy5vcmcvbGljZW5zZXMvYnkvMi41L4uG");
            sb.Append("PGUAAAAldEVYdG1vZGlmeS1kYXRlADIwMDYtMDMtMTJUMjE6NDk6MjItMDc6MDDiIWJzAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAABt0RVh0");
            sb.Append("U291cmNlAEZBTUZBTUZBTSBTaWxrIEljb25zgnpk+wAAADN0RVh0U291cmNlX1VSTABodHRwOi8vd3d3LmZhbWZhbWZhbS5jb20vbGFiL2ljb25zL3NpbGsvwsQNDQAA");
            sb.Append("AABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property BookLink_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void BookLink_Reset()
        {
            _BookLink = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití BookLink_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _BookLink = null;
        #endregion
        #region Image Book2Link
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku book2-link.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Book2Link_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Book2Link, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Book2Link_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book2-link.png
        /// </remarks>
        public static System.Drawing.Image Book2Link_Cached
        {
            get
            {
                if (_Book2Link == null) _Book2Link = Book2Link;
                return _Book2Link;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku book2-link.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image Book2Link_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Book2Link_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Book2Link_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book2-link.png
        /// </remarks>
        public static System.Drawing.Image Book2Link { get { return _ImageCreateFrom(_Book2Link_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru book2-link.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Book2Link_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Book2Link_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book2-link.png
        /// </remarks>
        public static System.Drawing.Image Book2Link_FromFile { get { return _ImageCreateFrom(_Book2Link_string, "book2-link.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru Book2Link
        /// </summary>
        /// <returns></returns>
        private static string _Book2Link_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1252);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwwAADsMBx2+oZAAAAER0RVh0U291cmNlAEZBTUZBTUZBTSBT");
            sb.Append("aWxrIEljb25zIGh0dHA6Ly93d3cuZmFtZmFtZmFtLmNvbS9sYWIvaWNvbnMvc2lsay+eJpWIAAAAGnRFWHRTb2Z0d2FyZQBQYWludC5ORVQgdjMuNS4xMDD0cqEAAALX");
            sb.Append("SURBVDhPrZPrT9JRGMd538v+g5qkZE3xBXOlmKamiM0SL2WZiGiili1J8ZppmjHTId6QmcsL6HTMW15mYstLUimFohDpT01aWuiy0Zv27ed55+xdne27PefZOZ/zPN9n");
            sb.Append("h8H4HyssXc3gpatneGnqt6FpTQiR0EpV4QKt4JuNCEppQGByPQJECvheK1k9G1d+8Fn68lx23QiGJ5dg/vQFizY7Fj9uwmTdwAfLOoxLa5g3U/hs34LD4QDLNxoHCLy0");
            sb.Append("ptW2l8u4XT2A+KIuXC/QEsXla3A1T4MruR2IzWknlZ0T1R4GhEqaKO2MDcoxE4ZNmxg0bmJgfgN979ahM6yh+/UqtNMreDpuQaik8TCA7pdqn7RC2jEF1fgyFM+NqNQZ");
            sb.Append("UNEzi7KuGTzoMqBMZ4RqdIn2peEwgDaLaqVbuNM6gZqh99j49hNr23ugaK1u7WHl6w8Uag2oHVqkTf0LgHaaah4341bzGKoGTCjvNuC+Zhr5bVOQtbyCtGUSuR0GVPWb");
            sb.Append("6InUH64gMLmBahwxIaFSB/mAGZmP1CgsLoVGo0GmNBeS6l5kqPS4KysguSxpNgQCQZaLi8sRMo3z4npKOWhEVNEzRIjvQaFQwOl0Ynd3FxaLBdK8YqTLSvDdsUNyNpuN");
            sb.Append("nGGz2RUEEJBUR1X1zoETmYFEcQrs29sIjhLCk81GeHg4lEolJBIJiT092fDk+BKIUCjcIQB/US31uOcN3M7wkZObRwAipR6uLHcsLCzAbrfDarVCr9eD6crC0RNcApDJ");
            sb.Append("ZE4C8EuspR52zoLFjcElQQwB+ITF0oCTcHd3B4fDIdqPXd1YOMX2du4DIiIiHATAFSqp0k4D8puG4XM+BPIn1RgafYGJiQmo1WrEx8cjNTWVxPu53r7+X3K53OHl5WUm");
            sb.Append("AN+EGoZ/Uj2OB+XgGDcFp728weNfRGRUNAS03PxuwIUrxmW6Onr/m8/n73l4eKwwmcx//8t/AB6S+IoSY/TrAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Book2Link_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Book2Link_Reset()
        {
            _Book2Link = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Book2Link_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Book2Link = null;
        #endregion
        #region Image Book3Link
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku book3-link.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Book3Link_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Book3Link, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Book3Link_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book3-link.png
        /// </remarks>
        public static System.Drawing.Image Book3Link_Cached
        {
            get
            {
                if (_Book3Link == null) _Book3Link = Book3Link;
                return _Book3Link;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku book3-link.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image Book3Link_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Book3Link_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Book3Link_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book3-link.png
        /// </remarks>
        public static System.Drawing.Image Book3Link { get { return _ImageCreateFrom(_Book3Link_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru book3-link.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Book3Link_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Book3Link_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book3-link.png
        /// </remarks>
        public static System.Drawing.Image Book3Link_FromFile { get { return _ImageCreateFrom(_Book3Link_string, "book3-link.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru Book3Link
        /// </summary>
        /// <returns></returns>
        private static string _Book3Link_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1224);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwgAADsIBFShKgAAAAER0RVh0U291cmNlAEZBTUZBTUZBTSBT");
            sb.Append("aWxrIEljb25zIGh0dHA6Ly93d3cuZmFtZmFtZmFtLmNvbS9sYWIvaWNvbnMvc2lsay+eJpWIAAAAGnRFWHRTb2Z0d2FyZQBQYWludC5ORVQgdjMuNS4xMDD0cqEAAALB");
            sb.Append("SURBVDhPrZPdT5JhGMY977A/wFLACWssW63mJwiIZEvSmlNnFvmZIorKhyCZoZilkRZiKCqKmR+lwBRF/KLMD3TzpMN8/wI7aLOTdvXwtA6cndW7Xdv93M/7/u77vp7n");
            sb.Append("jYr6H09W9UCU2KD+LDbUh0VNdUhvUiNdXwchkUBfC4FOhTRtDVLqq3Ct4u5hUqHlZFny8X6l7Tmc3lksbKxhfn2VyrcahHdlGZ5gAHPLSwhtbmJnZwdxkjScIJDKh1bP");
            sb.Append("WyhetuN2hwm57c1Ut9oMREbIzQZkE0U6S2qsPg0QNamZnvlJPHnvxPCKF4NBLwaCHjgCc7AvzeK1fwa9C9N45p2AiIx1qgMyL2P1vcPDkS5YPGNomRpE83g/9G47tKM2");
            sb.Append("1Ltt0E46YJlzEz+UpwHELOYFGaFsoAOPp53Y2N/F+t421va2sEq0Et5C7dgr0qGLAGpOA4jTTOfsGB7Y2/Boehg6dx/UIz1QEVU7ragcskJJAJE9gfYvHaTpVEz7jAt5");
            sb.Append("XUYYP4xA0aJFlUqJ7u5uFJeVoNjaCoWjE4rKcppTlJZCKpU2REdHn6GnkaqtYVqnhnCztR4Z9/NhNBpxcHCAcDgMv9+PEmUVipQV2N7dpblAIEDf4fF4TykgRaNkTBMD");
            sb.Append("SMi7gdy8O/i49Qmp8uvg8rgQCoUwmUwoKCigMZfLBe9SAoXk5OR8o4DkRiXTNP4G7JSrKKuooIDCfgti2Gz4fD6EQiEsLi7C5XLhHCsWZy/yKKC8vPyYAsjlYDRjfeBI");
            sb.Append("UiGRSSngSqaIAFhgEwifz6eKxDEsFuL4F44jALFYfEQBiQ1VTCNxXkmu8+XkRGj0OjiGnRgdHYXZbIZcLkd+fj6NIzmb3f5Do9EcEQ++/PbgXm9UMjme2KJcnJdnRiog");
            sb.Append("LV2IDFkmpDIZOFkSsLJlf9Y/BQLB9/j4+K8cDuff/+Vf7ZbNoSxh68YAAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Book3Link_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Book3Link_Reset()
        {
            _Book3Link = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Book3Link_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Book3Link = null;
        #endregion
        #region Image BookOpen
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku book-open.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu BookOpen_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property BookOpen, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property BookOpen_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book-open.png
        /// </remarks>
        public static System.Drawing.Image BookOpen_Cached
        {
            get
            {
                if (_BookOpen == null) _BookOpen = BookOpen;
                return _BookOpen;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku book-open.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image BookOpen_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití BookOpen_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property BookOpen_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book-open.png
        /// </remarks>
        public static System.Drawing.Image BookOpen { get { return _ImageCreateFrom(_BookOpen_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru book-open.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití BookOpen_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property BookOpen_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book-open.png
        /// </remarks>
        public static System.Drawing.Image BookOpen_FromFile { get { return _ImageCreateFrom(_BookOpen_string, "book-open.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru BookOpen
        /// </summary>
        /// <returns></returns>
        private static string _BookOpen_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1480);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAAAZiS0dEAAAAAAAA+UO7fwAAAAlwSFlzAAAASAAAAEgARslrPgAAAAl2cEFn");
            sb.Append("AAAAEAAAABAAXMatwwAAAhRJREFUOMulkzFrFEEUx38ne8l5kLuNotEkikoW8QhanHYHIYIRxEILv0HEysbKxkrwA4idQoqUYhFQITZipYZEgrHxDjFyhciluXMD2Xnv");
            sb.Append("7Vhs9kjgrDIwDMyb93+/+c+bgveeg4wA4O6LlXq+kZphu3Px/swawO0nr+sqgogg4hCXrR+f3VsrzD//XAdWTx8tk6aGWUpqRuKEn3+6F1WEidHDX/GGqqIiqCrffvxm");
            sb.Append("uDR8OfCprVI4xMOb5/tYaZqy/OUXzXZnWUW4dinixpVz+9Dr808ZKhZXAwAzA2BjYwOzrNLs9DRnjwQnR0YqnBobZX19HTMjjmMajQbOJYgbyjxQVQCiKMLMEBHa7Tbt");
            sb.Append("zU1qtRpJUiaKIkSEXq8HgEsS3PAQgfegIgA0m03SNEVEqFar9Ho9kiTpx1SVOI4ZHx/HOYc4R5CaIrsCURRlRqnS6XTY+8RTU1OoKt1uFwBxDhEhUFXEObz3tFqtvgeV");
            sb.Append("SqWfnMdygsnJyUzA7RHYS+CcY2trC+99nyInyD0QEVQcgUqWAFAqlfoVy+UyYRgShiFBEFAsFvcJ5lcNRBwuSZh5sNDvsBzvVuMC3nsW337KKqpiu4lmhooSiAhnJo4N");
            sb.Append("7PNXH1ZQUa7PzQ6MLy29IdjZ2WGz93dfj+cEJ8aOY2Ysv3s/kCA1o/C/3xjdebywvR1fVRGq4ej31stHc4POFQ76nf8Bhkab7qafS2MAAAAldEVYdGNyZWF0ZS1kYXRl");
            sb.Append("ADIwMDktMTEtMTZUMjI6MTg6MTYtMDc6MDD9d/V1AAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEwLTAxLTExVDA2OjUyOjUyLTA3OjAwxePiDgAAACV0RVh0ZGF0ZTptb2Rp");
            sb.Append("ZnkAMjAxMC0wMS0xMVQwNjo1Mjo1Mi0wNzowMLS+WrIAAABidEVYdExpY2Vuc2UAaHR0cDovL2NyZWF0aXZlY29tbW9ucy5vcmcvbGljZW5zZXMvYnkvMy4wLyBvciBo");
            sb.Append("dHRwOi8vY3JlYXRpdmVjb21tb25zLm9yZy9saWNlbnNlcy9ieS8yLjUvi4Y8ZQAAACV0RVh0bW9kaWZ5LWRhdGUAMjAwNi0wMy0xMlQyMTo0OToyNC0wNzowMIHxV0kA");
            sb.Append("AAAZdEVYdFNvZnR3YXJlAEFkb2JlIEltYWdlUmVhZHlxyWU8AAAAG3RFWHRTb3VyY2UARkFNRkFNRkFNIFNpbGsgSWNvbnOCemT7AAAAM3RFWHRTb3VyY2VfVVJMAGh0");
            sb.Append("dHA6Ly93d3cuZmFtZmFtZmFtLmNvbS9sYWIvaWNvbnMvc2lsay/CxA0NAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property BookOpen_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void BookOpen_Reset()
        {
            _BookOpen = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití BookOpen_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _BookOpen = null;
        #endregion
        #region Image Book1Open
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku book1-open.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Book1Open_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Book1Open, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Book1Open_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book1-open.png
        /// </remarks>
        public static System.Drawing.Image Book1Open_Cached
        {
            get
            {
                if (_Book1Open == null) _Book1Open = Book1Open;
                return _Book1Open;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku book1-open.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image Book1Open_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Book1Open_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Book1Open_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book1-open.png
        /// </remarks>
        public static System.Drawing.Image Book1Open { get { return _ImageCreateFrom(_Book1Open_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru book1-open.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Book1Open_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Book1Open_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book1-open.png
        /// </remarks>
        public static System.Drawing.Image Book1Open_FromFile { get { return _ImageCreateFrom(_Book1Open_string, "book1-open.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru Book1Open
        /// </summary>
        /// <returns></returns>
        private static string _Book1Open_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(988);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwwAADsMBx2+oZAAAABt0RVh0U291cmNlAEZBTUZBTUZBTSBT");
            sb.Append("aWxrIEljb25zgnpk+wAAABp0RVh0U29mdHdhcmUAUGFpbnQuTkVUIHYzLjUuMTAw9HKhAAACOklEQVQ4T6WTzWuTQRDGB3pQwaCHHqSoOWjbpPmUFYtSv9oeSm2TFkQQ");
            sb.Append("b4Ki/hEitFiKSdCLxVgSImIS83V4ExITEg1N80nyhiaNybGX/huPu1sTKJpTD8MuMzu/eWZ2lwDQSUwm2yw91je7ke+numxpcp/1wfPaGrt/scRuX9hh06NZduP8D2Y9");
            sb.Append("q8h4Pxmv7D1pLx908WJxH0/n9jCvbZjmLldNT2YqeDxTwKObeTyczmH1ehrmU1Fc08QZrVh6sJl7aLfbA2u1Wvi0qWL2UuXw3tju4dZG/VhcnNWPBMA0CiRg2XAEiEaj");
            sb.Append("CIfDCAQCaDQaUGI7+JVW0el0EIlEEAqF4PP55NlJ+gLrmcgRYEnXlU6RVKvVUCqVkEgk4Ha7kcvl0Gw2Ua/XUalUkM1m/wK2oRv5BuJDw8LVPekUVYQCv9+PeDwOl8uF");
            sb.Append("VColASIWDAbh9XohWtTTR4yTD7Rq/C2GJQH9KsViUQKcTucAIJSVy2VkMhkJMNB7DtgGLevbYlgDBaJPoUBRlAFAVdXBbDwejwQY6R1XsQVaHG/i7ljhmIJCoSABDocD");
            sb.Append("yWQSAlCtVuVs+gpMtAEdfQAtXGng1ujPf65RtJPP52WyqChaFKtoT6xmWucKXKBZbRn8ZYG/LFhOx+T9TtBXTvfhuT2GZ7YopnglAzm47E2e+BYWWuP2RvroDpe/Yt39");
            sb.Append("r03QZzntYXEDb4P42x6qgJ2LwKr5PlSBhV4P/4m8BS+vfsCv64Dv08N+7Im+soD+AamNm3YVFSbbAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Book1Open_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Book1Open_Reset()
        {
            _Book1Open = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Book1Open_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Book1Open = null;
        #endregion
        #region Image Book3Open
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku book3-open.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Book3Open_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Book3Open, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Book3Open_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book3-open.png
        /// </remarks>
        public static System.Drawing.Image Book3Open_Cached
        {
            get
            {
                if (_Book3Open == null) _Book3Open = Book3Open;
                return _Book3Open;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku book3-open.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image Book3Open_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Book3Open_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Book3Open_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book3-open.png
        /// </remarks>
        public static System.Drawing.Image Book3Open { get { return _ImageCreateFrom(_Book3Open_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru book3-open.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Book3Open_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Book3Open_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\book3-open.png
        /// </remarks>
        public static System.Drawing.Image Book3Open_FromFile { get { return _ImageCreateFrom(_Book3Open_string, "book3-open.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru Book3Open
        /// </summary>
        /// <returns></returns>
        private static string _Book3Open_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1032);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAAK/INwWK6QAAAAlwSFlzAAAOwwAADsMBx2+oZAAAABt0RVh0U291cmNlAEZBTUZBTUZBTSBT");
            sb.Append("aWxrIEljb25zgnpk+wAAABp0RVh0U29mdHdhcmUAUGFpbnQuTkVUIHYzLjUuMTAw9HKhAAACWUlEQVQ4T6VT7WvSURT+fYsoimJBg0VQjCgyaD/m6I0tLEWXaxmaLh1z");
            sb.Append("NceoZDSrTWi1ycTmT5kfZpsLzSBUfPmioiQKgvky2Qts7Pu+7N94uveGwig/7cPhXu455znPc+45HADuKMaSDT9cfMOG/E5e+83Bq1cX+AZwv9vKy5zTvMRu4XvnzPyd");
            sb.Append("j6948fQY8zeSYYmuYSqyismQF+afXkx8X4LSMytSuKyika8OjCzbYfDYoHPNQrNoxc0pI3pmTDynDzihDwrY3d1t2s7ODnzpBOTCzIH0y/uDlWT8kJ/GXn+jh/iDCQxA");
            sb.Append("519kAYlEArFYDOFwGJubm0jmsihUfmNvbw/xeBzRaBTBYJDFXhnXoOvt6F8AzZqdPdKker2OSqWCdDoNn8+HQqGA7e1tbGxsoFarIZ/Ps9hLxicQvR4CR5oGlXeePdIq");
            sb.Append("lEEoFEIqlYLb7UY2m2UA1BeJRBAIBEAlXtA/wlXCgiMdp81iAI0q5XKZAbhcriYAZVatVpHL5RjA+WcydL5QgVOvLNBmNRlQnZRBMplsAmxtbTV74/f7GUCb6j4uDg+A");
            sb.Append("Uy3P4aHj3SEGpVKJAQiCgEwmAwqwvr7OetNgcFp5Dx06ObgBzyf02Sb/+UYqp1gssmRakUqkJ5VHz5OK22jXSMEpBCvIZIFMFroso7hhNuDahBadY2qMCzaYnPNo18rQ");
            sb.Append("9lSCM4N9OKW8ixPyWzguE+OcSgJOSuhrlj7/1y4bB4lOZUv/2ce94Mhst2TQY3mJbjIsrRgce9DdehOJhEDH8/598l375P6r1cYeaZUp6B/IL6ZW8ozCcwAAAABJRU5E");
            sb.Append("rkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Book3Open_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Book3Open_Reset()
        {
            _Book3Open = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Book3Open_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Book3Open = null;
        #endregion
        #region Image CodeClass
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku code-class.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu CodeClass_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property CodeClass, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property CodeClass_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\code-class.png
        /// </remarks>
        public static System.Drawing.Image CodeClass_Cached
        {
            get
            {
                if (_CodeClass == null) _CodeClass = CodeClass;
                return _CodeClass;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku code-class.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image CodeClass_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití CodeClass_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property CodeClass_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\code-class.png
        /// </remarks>
        public static System.Drawing.Image CodeClass { get { return _ImageCreateFrom(_CodeClass_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru code-class.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití CodeClass_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property CodeClass_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\code-class.png
        /// </remarks>
        public static System.Drawing.Image CodeClass_FromFile { get { return _ImageCreateFrom(_CodeClass_string, "code-class.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru CodeClass
        /// </summary>
        /// <returns></returns>
        private static string _CodeClass_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1520);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAA");
            sb.Append("OpgAABdwnLpRPAAAAAZiS0dEAAAAAAAA+UO7fwAAAAlwSFlzAAADdgAAA3YBfdWCzAAAAAl2cEFnAAAAEAAAABAAXMatwwAAAitJREFUOMuNkktIVHEUxn//e++MZkVm");
            sb.Append("+EqyEJLIqJAWhhHULKpFGxdtA4Ue0GJoE0agkCgEUUhgELrpsdFaFVSik1gkJKI0aoKZ41jjY5wcnblz3/8WhivBOevv/M453/nEcPTV7c8zz9qmlkJ+ACGgeFdlpvrA");
            sb.Append("lebLVS0P2KbE/XfnzKuBBr8HeJ6N41k4XoqP34YIBroFQODxEH3Bmi0B2tepkP/MiWrSxhqOa+J6NqoKvd+7N0V9wRreT8Qb347+bh2O/AWgYGcOwUBFu5Zch/G5UVL6");
            sb.Append("OqaTIW2ukjLjpE0NcDqAHKC+Z3Citex0DeePSAxHYtiSL+PhW9paSqV/JITrCRQhQAhURbAS9wBuAk+ApwPhCJX7q9B1i7ThspgW5IbHFM0nCjKKtHbYjosEJKD4VPLz");
            sb.Append("9gKzAHlAvZ5YuD4yuYxlmRsa1Y+TTKCV5JffS6zoD2cWfm3eXJS/j/Lisjv/ARIgV/OIk0ZRJAC26lC622+I7d4EdAINl9qeN83OLzZPR2IAlBYVcOrY4aYs+ukEkFJu");
            sb.Append("OUzJhrARMCG3zEG2APPPy8bVn12txlI/AGpOCXuOP2rPxoMuoH76dUBW1F0AqYB0QTGZ64162WwggY7EWB+HLlbiZpJIN4kqw8x+iinZABoAFqLKDTvag6Wvg3Tw5fpI");
            sb.Append("xtzsPbCdQlLLqwgpAA1L98B/0FA/3D3Li8HItoBrdbXujwFRO/JmWZsMucxPlBiFR0+2/AM8rPM5fdqBuwAAACV0RVh0Y3JlYXRlLWRhdGUAMjAwOS0xMS0xNVQxNzow");
            sb.Append("MjozNC0wNzowMLbnjhIAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTAtMDEtMTFUMDk6MjQ6NDEtMDc6MDA79Ej8AAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEwLTAxLTExVDA5");
            sb.Append("OjI0OjQxLTA3OjAwSqnwQAAAAGd0RVh0TGljZW5zZQBodHRwOi8vY3JlYXRpdmVjb21tb25zLm9yZy9saWNlbnNlcy9ieS1zYS8zLjAvIG9yIGh0dHA6Ly9jcmVhdGl2");
            sb.Append("ZWNvbW1vbnMub3JnL2xpY2Vuc2VzL0xHUEwvMi4xL1uPPGMAAAAldEVYdG1vZGlmeS1kYXRlADIwMDktMDctMjFUMDk6MjM6MzItMDY6MDCdbbIWAAAAE3RFWHRTb3Vy");
            sb.Append("Y2UAT3h5Z2VuIEljb25z7Biu6AAAACd0RVh0U291cmNlX1VSTABodHRwOi8vd3d3Lm94eWdlbi1pY29ucy5vcmcv7zeqywAAAABJRU5ErkJggg==");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property CodeClass_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void CodeClass_Reset()
        {
            _CodeClass = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití CodeClass_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _CodeClass = null;
        #endregion
        #region Image Configure2
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku configure-2.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Configure2_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Configure2, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Configure2_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\configure-2.png
        /// </remarks>
        public static System.Drawing.Image Configure2_Cached
        {
            get
            {
                if (_Configure2 == null) _Configure2 = Configure2;
                return _Configure2;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku configure-2.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image Configure2_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Configure2_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Configure2_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\configure-2.png
        /// </remarks>
        public static System.Drawing.Image Configure2 { get { return _ImageCreateFrom(_Configure2_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru configure-2.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Configure2_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Configure2_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\configure-2.png
        /// </remarks>
        public static System.Drawing.Image Configure2_FromFile { get { return _ImageCreateFrom(_Configure2_string, "configure-2.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru Configure2
        /// </summary>
        /// <returns></returns>
        private static string _Configure2_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1868);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABmJLR0QAAAAAAAD5Q7t/AAAACXBIWXMAAABIAAAASABGyWs+AAAACXZwQWcAAAAQAAAAEABcxq3DAAAD");
            sb.Append("qklEQVQ4y22Ta0xbBRiGv3Or7TmnFHpOS2kPbVnBrUhn5gJCMjZxOLYMhzGZ4rJEjT+MGLPEjEAWbzET2UWi0ezioiZLDJlzRQZsHT+8jRoG0qEMGL2vpbS0KYXSlt5O");
            sb.Append("jz+MM1v2/X6fJ2/e5EM++uBDqraurmHUYpkp1+mWj3YehUcc2tPzaS3HaTaDAHPZLH97bnaG7/u8D1CHfUHOskz3821tJ68Njyh/vPTDw/Bjp0+eOrizcce3CgV7Tijw");
            sb.Append("7fNzs5JEMokCAKBer2fJ4/acpSiyvqu7qzObzYqvDpjv0zVPmNjnWvZ0VFToq4OBgC8YDP2qVLJd5Rp1MQAASlM0337oFfP42NhbpES8S1WmOhaNRomL330DAAC7m5pk");
            sb.Append("MplMLggADMNqDZVVxzUct3k9Ec8CAGAujwcAACyjo56BS/3TWp3ubYqmtf5IxPqqSMcnKtQ1SpZ5fco2TTIKJcFxXOSv6b97b01MOZ1OewH/r6qcIMDp802azeZuo8n0");
            sb.Append("xTa9NnXZ5ey/kX/ySJJF2O1KMrwYCNnSG5nf7QsOqwD5HAAA8ojFkf7vL+58mlGciI7dVlotM7oL6sO2rao7fbTgsgaWIiF9OZc9c+5LAADAHqabP7kFI9e8Od3C5EtP");
            sb.Append("MYLJsLGI1M0Nnm4wpC6k7Utr3LO7+d4Tx+/nHxA0HrMCXiTVuNel5+N35psqnTeR4spNQOB8tds6Hc37ff702G8bh4qkcDWZelCwrfNn4DRFZYF7ifNhP9KaqG/hkULy");
            sb.Append("jGripxDTuKtOrFLt83k81elc7s+BdDZ2L5f7X2DqngVMWFeFfOmvFl2ZF4q2GARcQZmvV+17t2X4vfm1lVhz1f79LKlQGMNOx/ZKFBl/jaIj5lQKsNKDQ1DCYMXJhKg3");
            sb.Append("6Mq0kzo9Ki0T25ft3iOqEsTb9sfZQDi+Hs/7/c3GAwdEkhK5Nu5wGPOZzC89O7bGMbrmMCpQ2g5EzL5BlSopSkmF48uxjhfrr9yceP9l6EcxaEBxp7C2pkDdbtPjra04");
            sb.Append("SZIVokiElcrEFoxPFuNImekddgtjoiT5TGBq8uPojVMDzsGvMQEnCB7FCYsABb2ATOKxWLLgdtdu2rtXJDca59Oeu4NYfjUuEGhWwBCCjk4MXV8ZeXNIkryrFjCkqoCg");
            sb.Append("Bh5QfaEA6vF8QTSczNjY1ZUVzepq0JbJfFaaiPoB0GdAEAQAAAoAxEUAUhoBlsRBJZbgGlxKaYCmS4Gk5EDKaADAAQBLXPn34f4BnGqOR7LhlugAAAAldEVYdGNyZWF0");
            sb.Append("ZS1kYXRlADIwMDktMTEtMjhUMTc6MTg6MjgtMDc6MDAxkbIsAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDEwLTAyLTIwVDIzOjI2OjE1LTA3OjAwBjtcgQAAACV0RVh0ZGF0");
            sb.Append("ZTptb2RpZnkAMjAxMC0wMS0xMVQwODo0Mjo1MC0wNzowMBhJmOsAAAA1dEVYdExpY2Vuc2UAaHR0cDovL2NyZWF0aXZlY29tbW9ucy5vcmcvbGljZW5zZXMvTEdQTC8y");
            sb.Append("LjEvO8G0GAAAACV0RVh0bW9kaWZ5LWRhdGUAMjAwOS0xMS0yOFQxNDozMjoxNC0wNzowMNWL7EkAAAAWdEVYdFNvdXJjZQBDcnlzdGFsIFByb2plY3Tr4+SLAAAAJ3RF");
            sb.Append("WHRTb3VyY2VfVVJMAGh0dHA6Ly9ldmVyYWxkby5jb20vY3J5c3RhbC+lkZNbAAAAAElFTkSuQmCC");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Configure2_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Configure2_Reset()
        {
            _Configure2 = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Configure2_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Configure2 = null;
        #endregion
        #region Image Link
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku link.png.
        /// Vrací přímou referenci na objekt v paměti = volání je velice rychlé (pod 1 mikrosekundu), 
        /// ale protože se vrací živá reference, pak zásahy do vráceného objektu se projeví v objektu v paměti = natrvalo.
        /// Případně je možno vyvolat metodu Link_Reset(), která zajistí regenerování obrázku z jeho definice.
        /// Bezpečnější je používání property Link, která vrací vždy nový objekt.
        /// Pro používání pro Button.Image, kde bude nastavováno Button.Enabled = false; je třeba použít property Link_FromFile.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\link.png
        /// </remarks>
        public static System.Drawing.Image Link_Cached
        {
            get
            {
                if (_Link == null) _Link = Link;
                return _Link;
            }
        }
        /// <summary>
        /// Vrátí obrázek, vytvořený na základě obrázku link.png.
        /// Nelze používat jako Image pro Buttony, kde bude nastavováno Enabled = false (pak dojde k chybě .NET: Ot of memory).
        /// Pak je třeba použít Image Link_FromFile.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Link_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Link_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\link.png
        /// </remarks>
        public static System.Drawing.Image Link { get { return _ImageCreateFrom(_Link_string, null); } }
        /// <summary>
        /// Vrátí obrázek, načtený ze souboru link.png.
        /// Vrací vždy novou instanci = volání je při častém používání výrazně (až 1000krát) pomalejší než použití Link_Cached
        /// (kde ale hrozí nebezpečí pokažení obrázku v paměti).
        /// Čas pro vytvoření jednoho Image (tj. každé jednotlivé čtení této property) pro obrázek velikosti 32x32 px (32bpp) je průměrně 350 mikrosekund.
        /// Pokud je třeba používat obrázek často a rychle, je možné využít property Link_Cached.
        /// </summary>
        /// <remarks>
        /// Plné jméno vstupního souboru:
        /// C:\LCS\Tools\GreenSchedule4\Schedule\pic\pic16\link.png
        /// </remarks>
        public static System.Drawing.Image Link_FromFile { get { return _ImageCreateFrom(_Link_string, "link.png"); } }
        /// <summary>
        /// Vygeneruje a vrátí string, který definuje obsah souboru Link
        /// </summary>
        /// <returns></returns>
        private static string _Link_string()
        {
            System.Text.StringBuilder sb = new System.Text.StringBuilder(1120);
            sb.Append("iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAQAAAC1+jfqAAAABGdBTUEAAK/INwWK6QAAAAJiS0dEAACqjSMyAAAACXBIWXMAAABIAAAASABGyWs+AAAACXZwQWcAAAAQ");
            sb.Append("AAAAEABcxq3DAAABCUlEQVQoz2P8z4AfMDHQXAELAwMDgz23TpZ0paTgvUcfwhgeChxVUnr+/mn7lWkHvzIwMP5nMGaTanEtDWf4yvCE4cD9X0/izFjYnzOcZdjd/azm");
            sb.Append("7C/G/wxGfk6Lkv41n/jsJsWsy/Cc4Q3Ds7+8uwK0T/Pvizu3iYmBgdGGn31f5feQL98jGGwYPBk8GL58/x7yuo2fndGGgYGFgeH3/ac/RHiZ1zOxdzJwMzAwfGVgYmde");
            sb.Append("z7z76Y/f9xkYWBgY/hx49kKtOuIfC+tLhlsM7AzyDOKsf0wemz178ecAAwPjfwZ1Zkld7vVSouzMDExvUhmeiqxnYP3599nrr4HPL9/8yzgIgpqgAgAhC16qmeXtNAAA");
            sb.Append("ACV0RVh0Y3JlYXRlLWRhdGUAMjAwOS0xMS0xNlQyMjoxODoxNy0wNzowMFsA/sEAAAAldEVYdGRhdGU6Y3JlYXRlADIwMTAtMDEtMTFUMDY6NTM6MDgtMDc6MDDGsdga");
            sb.Append("AAAAJXRFWHRkYXRlOm1vZGlmeQAyMDEwLTAxLTExVDA2OjUzOjA4LTA3OjAwt+xgpgAAAGJ0RVh0TGljZW5zZQBodHRwOi8vY3JlYXRpdmVjb21tb25zLm9yZy9saWNl");
            sb.Append("bnNlcy9ieS8zLjAvIG9yIGh0dHA6Ly9jcmVhdGl2ZWNvbW1vbnMub3JnL2xpY2Vuc2VzL2J5LzIuNS+LhjxlAAAAJXRFWHRtb2RpZnktZGF0ZQAyMDA2LTAzLTEyVDIx");
            sb.Append("OjU0OjE0LTA3OjAwOw4E2gAAABl0RVh0U29mdHdhcmUAQWRvYmUgSW1hZ2VSZWFkeXHJZTwAAAAbdEVYdFNvdXJjZQBGQU1GQU1GQU0gU2lsayBJY29uc4J6ZPsAAAAz");
            sb.Append("dEVYdFNvdXJjZV9VUkwAaHR0cDovL3d3dy5mYW1mYW1mYW0uY29tL2xhYi9pY29ucy9zaWxrL8LEDQ0AAAAASUVORK5CYII=");
            return sb.ToString();
        }
        /// <summary>
        /// Resetuje obrázek v paměti.
        /// Následující použití property Link_Direct si vytvoří nový, korektní - podle jeho originální deklarace.
        /// Tuto metodu je vhodné použít v situaci, kdy je správnost obrázku v paměti nejistá.
        /// </summary>
        public static void Link_Reset()
        {
            _Link = null;
        }
        /// <summary>
        /// Úložiště objektu v paměti, při prvním použití Link_Direct je objekt naplněn a následně využíván.
        /// </summary>
        private static System.Drawing.Image _Link = null;
        #endregion
        #region SPOLEČNÉ METODY PRO KONVERZI
        /// <summary>
        /// Vrátí Image z definice (string). Image generuje buď v paměti, anebo s pomocí souboru.
        /// Pokud není zadán parametr (cacheFileName) (když je null), generuje se Image v paměti.
        /// Pokud je soubor (cacheFileName) definován, pak se Image čte z něj.
        /// Pokud soubor neexistuje, nejprve se vytvoří.
        /// Umístění souboru (adresář) je dán property _ImageCacheDir, defaultně je to adresář (Sys:\Documents and Settings\All Users\Data aplikací\IconCache).
        /// Obsah obrázku definuje metoda getDataMethod.
        /// </summary>
        /// <param name="getDataMethod"></param>
        /// <param name="cacheFileName"></param>
        /// <returns></returns>
        private static System.Drawing.Image _ImageCreateFrom(_GetStringDelegate getDataMethod, string cacheFileName)
        {
            System.Drawing.Image image;
            if (cacheFileName == null)
            {
                using (System.IO.MemoryStream ms = new System.IO.MemoryStream(Convert.FromBase64String(getDataMethod())))
                {
                    image = System.Drawing.Image.FromStream(ms);
                }
                return image;
            }
            string fileName = System.IO.Path.Combine(_ImageCacheDir, cacheFileName);
            if (!System.IO.File.Exists(fileName))
                System.IO.File.WriteAllBytes(fileName, Convert.FromBase64String(getDataMethod()));
            if (System.IO.File.Exists(fileName))
                return Image.FromFile(fileName);
            return null;
        }
        /// <summary>
        /// Obsahuje jméno adresáře, který slouží jako Cache pro obrázky systému.
        /// </summary>
        private static string _ImageCacheDir
        {
            get
            {
                string dirName = System.IO.Path.Combine(System.Environment.GetFolderPath(System.Environment.SpecialFolder.CommonApplicationData), "PicLibrary\\SchedulerPic16");
                if (!System.IO.Directory.Exists(dirName))
                    System.IO.Directory.CreateDirectory(dirName);
                return dirName;
            }
        }
        /// <summary>
        /// Předpis pro metody, které generují obsah souboru s daty
        /// </summary>
        /// <returns></returns>
        private delegate string _GetStringDelegate();
        /// <summary>
        /// Vrátí Icon z dat (string), která jsou předána na vstup v kódování Base64
        /// </summary>
        /// <param name="data">Vstupní data v kódování Base64</param>
        /// <returns>Icon vytvořená z dat</returns>
        public static System.Drawing.Icon ConvertStringToIcon(string data)
        {
            System.Drawing.Icon icon;
            using (System.IO.MemoryStream ms = new System.IO.MemoryStream(Convert.FromBase64String(data)))
            {
                icon = new System.Drawing.Icon(ms);
            }
            return icon;
        }
        /// <summary>
        /// Vrátí Cursor z dat (string), která jsou předána na vstup v kódování Base64
        /// </summary>
        /// <param name="data">Vstupní data v kódování Base64</param>
        /// <returns>Cursor vytvořený z dat</returns>
        public static System.Windows.Forms.Cursor ConvertStringToCursor(string data)
        {
            System.Windows.Forms.Cursor cursor;
            using (System.IO.MemoryStream ms = new System.IO.MemoryStream(Convert.FromBase64String(data)))
            {
                cursor = new System.Windows.Forms.Cursor(ms);
            }
            return cursor;
        }
        #endregion
    }
}
